home *** CD-ROM | disk | FTP | other *** search
/ PC go! 2008 April / PCgo 2008-04 (DVD).iso / interface / contents / demoversionen_3846 / 13664 / files / Data1.cab / propmodify.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-10-16  |  7.7 KB  |  351 lines
  1. /******************************************************************/
  2. /*                                                                */
  3. /*                      TurboCAD for Windows                      */
  4. /*                   Copyright (c) 1993 - 2001                    */
  5. /*             International Microcomputer Software, Inc.         */
  6. /*                            (IMSI)                              */
  7. /*                      All rights reserved.                      */
  8. /*                                                                */
  9. /******************************************************************/
  10.  
  11. // propmodify.cpp : implementation file
  12. //
  13.  
  14. #include "stdafx.h"
  15. #include "LTSample.h"
  16. #include "propmodify.h"
  17.  
  18. #ifdef _DEBUG
  19. #define new DEBUG_NEW
  20. #undef THIS_FILE
  21. static char THIS_FILE[] = __FILE__;
  22. #endif
  23.  
  24. #define W_EDIT    50
  25. #define H_EDIT    20
  26.  
  27. void PutVoidToVariant(VARIANT& varVal, void* pvoid)
  28. {
  29.     switch (varVal.vt)
  30.     {
  31.         case VT_I2:
  32.             varVal.iVal = *((SHORT *)pvoid);
  33.         break;
  34.         case VT_I4:
  35.             varVal.lVal = *((long *)pvoid);
  36.         break;
  37.         case VT_R4:
  38.             varVal.fltVal = *((float *)pvoid);
  39.         break;
  40.         case VT_R8:
  41.             varVal.dblVal = *((double *)pvoid);
  42.         break;    
  43.         case VT_CY:
  44.             varVal.cyVal = *((CY *)pvoid);
  45.         break;
  46.         case VT_DATE:
  47.             varVal.date = *((DATE *)pvoid);
  48.         break;
  49.         case VT_BSTR:
  50.             varVal.bstrVal = *((BSTR *)pvoid);
  51.         break;
  52.         case VT_BOOL:
  53.             varVal.boolVal = *((BOOL *)pvoid);
  54.         break;
  55.         default:
  56.             varVal.vt = VT_EMPTY;
  57.     }
  58. }
  59.  
  60. void PutVariantToVoid(void* pvoid, VARIANT& varVal)
  61. {
  62.     switch (varVal.vt)
  63.     {
  64.         case VT_I2:
  65.             *((SHORT *)pvoid) = varVal.iVal;
  66.         break;
  67.         case VT_I4:
  68.             *((long *)pvoid) = varVal.lVal;
  69.         break;
  70.         case VT_R4:
  71.             *((float *)pvoid) = varVal.fltVal;
  72.         break;
  73.         case VT_R8:
  74.             *((double *)pvoid) = varVal.dblVal;
  75.         break;    
  76.         case VT_CY:
  77.             *((CY *)pvoid) = varVal.cyVal;
  78.         break;
  79.         case VT_DATE:
  80.             *((DATE *)pvoid) = varVal.date;
  81.         break;
  82.         case VT_BSTR:
  83.             *((BSTR *)pvoid) = varVal.bstrVal;
  84.         break;
  85.         case VT_BOOL:
  86.             *((BOOL *)pvoid) = varVal.boolVal;
  87.         break;
  88.         default:
  89.             ASSERT(FALSE);
  90.     }
  91. }
  92.  
  93.  
  94. void AFXAPI DDX_Text(CDataExchange* pDX, int nIDC, VARIANT& varVal)
  95. {
  96.     switch (varVal.vt)
  97.     {
  98.         case VT_I2:
  99.             DDX_Text(pDX, nIDC, varVal.iVal);
  100.         break;
  101.         case VT_I4:
  102.             DDX_Text(pDX, nIDC, varVal.lVal);
  103.         break;
  104.         case VT_R4:
  105.             DDX_Text(pDX, nIDC, varVal.fltVal);
  106.         break;
  107.         case VT_R8:
  108.             DDX_Text(pDX, nIDC, varVal.dblVal);
  109.         break;    
  110.         case VT_CY:
  111.         {
  112.             COleCurrency cy(varVal.cyVal);
  113.             DDX_Text(pDX, nIDC, cy);
  114.             if (pDX->m_bSaveAndValidate)
  115.                 varVal.cyVal = cy;
  116.         }
  117.         break;
  118.         case VT_DATE:
  119.         {
  120.             COleDateTime date(varVal.date);
  121.             DDX_Text(pDX, nIDC, date);
  122.             if (pDX->m_bSaveAndValidate)
  123.                 varVal.date = date;
  124.         }
  125.         break;
  126.         case VT_BSTR:
  127.         {
  128.             CString cstrVal(varVal.bstrVal);
  129.             DDX_Text(pDX, nIDC, cstrVal);
  130.  
  131.             if (pDX->m_bSaveAndValidate)
  132.             {
  133.                 if (varVal.bstrVal != NULL)
  134.                     SysFreeString(varVal.bstrVal);
  135.                 varVal.bstrVal = cstrVal.AllocSysString();
  136.             }
  137.         }
  138.         break;
  139.         case VT_BOOL:
  140.         {
  141.             CString cstrText(varVal.boolVal ? "True" : "False");
  142.             
  143.             DDX_Text(pDX, nIDC, cstrText);
  144.  
  145.             if (pDX->m_bSaveAndValidate)
  146.             {
  147.                 if (cstrText.CompareNoCase("True") == 0)
  148.                     varVal.boolVal = 1;
  149.                 else
  150.                 {
  151.                     if (cstrText.CompareNoCase("False"))
  152.                         varVal.boolVal = 0;
  153.                     else
  154.                         pDX->Fail();                    
  155.                 }
  156.             }
  157.         }
  158.         break;
  159.         default:
  160.             varVal.vt = VT_EMPTY;
  161.             pDX->Fail();
  162.     }
  163. }
  164.  
  165. /////////////////////////////////////////////////////////////////////////////
  166. // CPropModify dialog
  167.  
  168.  
  169. CPropModify::CPropModify(COleVariant *pvarVal, LPCTSTR cszName, LPCTSTR cszType, CWnd* pParent /*=NULL*/)
  170.     : CDialog(CPropModify::IDD, pParent)
  171. {
  172.     m_cstrName = cszName;
  173.     m_cstrType = cszType;
  174.     ::VariantCopyInd(m_varVal, pvarVal);
  175.     m_bInitDone = FALSE;
  176.     //{{AFX_DATA_INIT(CPropModify)
  177.         // NOTE: the ClassWizard will add member initialization here
  178.     //}}AFX_DATA_INIT
  179. }
  180.  
  181. void CPropModify::DoDataExchange(CDataExchange* pDX)
  182. {
  183.     CDialog::DoDataExchange(pDX);
  184.     if (m_bInitDone)
  185.     {
  186.         int iUpper = m_arrWnd.GetUpperBound();
  187.         CEdit *pEdit = NULL;
  188.         UINT IDC_EDIT = IDC_VAL + 1;
  189.         if (m_varVal.vt & VT_ARRAY)
  190.         {
  191.             long lLBound, lUBound;
  192.             VARIANT varVal;
  193.             ::VariantInit(&varVal);
  194.  
  195.             varVal.vt = m_varVal.vt & ~VT_ARRAY;
  196.             UINT nSize = SafeArrayGetElemsize(m_varVal.parray);
  197.             void *pelem = (void *)new BYTE[nSize];
  198.  
  199.             HRESULT  hRes = SafeArrayGetLBound(m_varVal.parray, 1, &lLBound);
  200.             ASSERT(SUCCEEDED(hRes));
  201.             hRes = SafeArrayGetUBound(m_varVal.parray, 1, &lUBound);
  202.             ASSERT(SUCCEEDED(hRes));
  203.             for (long lItem = lLBound; lItem <= lUBound; lItem++)
  204.             {
  205.                 if (pDX->m_bSaveAndValidate)
  206.                 {
  207.                     DDX_Text(pDX, IDC_EDIT, varVal);
  208.                     PutVariantToVoid(pelem, varVal);
  209.                     VERIFY(SUCCEEDED(SafeArrayPutElement(m_varVal.parray, &lItem, pelem)));
  210.                 }
  211.                 else
  212.                 {
  213.                     if (SUCCEEDED(SafeArrayGetElement(m_varVal.parray, &lItem, pelem)))
  214.                     {
  215.                         PutVoidToVariant(varVal, pelem);
  216.                         DDX_Text(pDX, IDC_EDIT, varVal);
  217.                     }
  218.                 }
  219.                 
  220.                 IDC_EDIT++;
  221.             }
  222.             delete[] pelem;
  223.  
  224.         }
  225.         else
  226.         {
  227.             DDX_Text(pDX, IDC_EDIT, m_varVal);
  228.         }
  229.     }
  230. }
  231.  
  232.  
  233. BEGIN_MESSAGE_MAP(CPropModify, CDialog)
  234.     //{{AFX_MSG_MAP(CPropModify)
  235.     //}}AFX_MSG_MAP
  236. END_MESSAGE_MAP()
  237.  
  238. /////////////////////////////////////////////////////////////////////////////
  239. // CPropModify message handlers
  240.  
  241. BOOL CPropModify::OnInitDialog() 
  242. {
  243.     CDialog::OnInitDialog();
  244.     
  245.     CStatic *pWnd = (CStatic *)GetDlgItem(IDC_NAME);
  246.     if (pWnd != NULL)
  247.     {
  248.         pWnd->SetWindowText(m_cstrName);
  249.     }
  250.  
  251.     pWnd = (CStatic *)GetDlgItem(IDC_TYPE);
  252.     if (pWnd != NULL)
  253.     {
  254.         pWnd->SetWindowText(m_cstrType);
  255.     }
  256.  
  257.     CRect rect;
  258.     pWnd = (CStatic *)GetDlgItem(IDC_VAL);
  259.     pWnd->GetWindowRect(&rect);
  260.     ScreenToClient(&rect);
  261.  
  262.     CRect rectEdit;
  263.     CEdit *pEdit = NULL;
  264.  
  265.     rectEdit.top = rect.bottom + 2;
  266.     rectEdit.bottom = rectEdit.top + H_EDIT;
  267.     UINT IDC_EDIT = IDC_VAL + 1;
  268.  
  269.     if (m_varVal.vt & VT_ARRAY)
  270.     {
  271.         int dx = 0, dy = 0;
  272.         UINT nDim = SafeArrayGetDim(m_varVal.parray);
  273.         if (nDim > 1)
  274.         {
  275.             AfxMessageBox("IDS_CANNOTTPROCESSPROPERTYDATA");
  276.             return FALSE;
  277.         }
  278.  
  279.         long lLBound, lUBound;
  280.         long max_dx = 0;
  281.  
  282.         HRESULT hRes = SafeArrayGetLBound(m_varVal.parray, 1, &lLBound);
  283.         ASSERT(SUCCEEDED(hRes));
  284.         hRes = SafeArrayGetUBound(m_varVal.parray, 1, &lUBound);
  285.         ASSERT(SUCCEEDED(hRes));
  286.         rectEdit.left = rect.left;
  287.         for (long lItem = lLBound; lItem <= lUBound; lItem++)
  288.         {
  289.             pEdit = new CEdit();
  290.             rectEdit.right = rectEdit.left + W_EDIT;
  291.             pEdit->Create(WS_CHILD
  292.                           | WS_VISIBLE
  293.                           | WS_BORDER
  294.                           | ES_AUTOHSCROLL
  295.                           | ES_LEFT,
  296.                           rectEdit,
  297.                           this,
  298.                           IDC_EDIT);
  299.  
  300.             pEdit->SetFont(GetFont());
  301.             m_arrWnd.Add(pEdit);
  302.             rectEdit.left = rectEdit.right + 2;
  303.             IDC_EDIT++;
  304.         }
  305.         
  306.     }
  307.     else
  308.     {
  309.         rectEdit.left = rect.left + (rect.Width() - W_EDIT) / 2;
  310.         rectEdit.right = rectEdit.left + W_EDIT;
  311.  
  312.         pEdit = new CEdit();
  313.         pEdit->Create(WS_CHILD
  314.                       | WS_VISIBLE
  315.                       | WS_BORDER
  316.                       | ES_AUTOHSCROLL
  317.                       | ES_LEFT,
  318.                       rectEdit,
  319.                       this,
  320.                       IDC_EDIT);
  321.  
  322.         pEdit->SetFont(GetFont());
  323.  
  324.         m_arrWnd.Add(pEdit);
  325.     }            
  326.     m_bInitDone = TRUE;
  327.     UpdateData(FALSE);
  328.  
  329.     return TRUE;  // return TRUE unless you set the focus to a control
  330.                   // EXCEPTION: OCX Property Pages should return FALSE
  331. }
  332.  
  333. BOOL CPropModify::DestroyWindow() 
  334. {
  335.     int iUpper = m_arrWnd.GetUpperBound();
  336.     CEdit *pEdit = NULL;
  337.     for (int iItem = 0; iItem <= iUpper; iItem ++)
  338.     {
  339.         pEdit = (CEdit *)m_arrWnd.GetAt(iItem);
  340.         m_arrWnd.SetAt(iItem, NULL);
  341.  
  342.         if (pEdit != NULL)
  343.             delete pEdit;
  344.  
  345.         pEdit = NULL;
  346.     }
  347.  
  348.     
  349.     return CDialog::DestroyWindow();
  350. }
  351.